// 认证工具函数

/**
 * 获取当前登录用户的token
 * @returns {string|null} token字符串或null
 */
export const getToken = () => {
  return localStorage.getItem('userToken') || sessionStorage.getItem('userToken') || null;
};

/**
 * 设置用户token
 * @param {string} token - 用户token
 * @param {boolean} rememberMe - 是否记住用户（true表示持久化存储）
 */
export const setToken = (token, rememberMe = false) => {
  if (rememberMe) {
    localStorage.setItem('userToken', token);
  } else {
    sessionStorage.setItem('userToken', token);
  }
};

/**
 * 清除用户token
 */
export const removeToken = () => {
  localStorage.removeItem('userToken');
  sessionStorage.removeItem('userToken');
};

/**
 * 获取当前登录用户的角色
 * @returns {string|number|null} 角色信息或null
 */
export const getRole = () => {
  const role = localStorage.getItem('userRole') || sessionStorage.getItem('userRole') || null;
  return role ? (isNaN(role) ? role : parseInt(role)) : null;
};

/**
 * 设置用户角色
 * @param {string|number} role - 用户角色
 * @param {boolean} rememberMe - 是否记住用户（true表示持久化存储）
 */
export const setRole = (role, rememberMe = false) => {
  if (rememberMe) {
    localStorage.setItem('userRole', role.toString());
  } else {
    sessionStorage.setItem('userRole', role.toString());
  }
};

/**
 * 清除用户角色
 */
export const removeRole = () => {
  localStorage.removeItem('userRole');
  sessionStorage.removeItem('userRole');
};

/**
 * 检查用户是否已登录
 * @returns {boolean} 是否已登录
 */
export const isAuthenticated = () => {
  return getToken() !== null;
};

/**
 * 检查用户是否具有指定角色
 * @param {string|number|array} roles - 角色或角色数组
 * @returns {boolean} 是否具有指定角色
 */
export const hasRole = (roles) => {
  const userRole = getRole();
  if (!userRole) {
    return false;
  }
  
  if (Array.isArray(roles)) {
    return roles.includes(userRole);
  }
  return userRole === roles;
};

/**
 * 获取当前登录用户的教师ID
 * @returns {string|null} 教师ID或null
 */
export const getTeacherId = () => {
  return localStorage.getItem('teacherId') || sessionStorage.getItem('teacherId') || null;
};

/**
 * 设置用户教师ID
 * @param {string} teacherId - 教师ID
 * @param {boolean} rememberMe - 是否记住用户（true表示持久化存储）
 */
export const setTeacherId = (teacherId, rememberMe = false) => {
  if (rememberMe) {
    localStorage.setItem('teacherId', teacherId);
  } else {
    sessionStorage.setItem('teacherId', teacherId);
  }
};

/**
 * 清除用户教师ID
 */
export const removeTeacherId = () => {
  localStorage.removeItem('teacherId');
  sessionStorage.removeItem('teacherId');
};

/**
 * 获取当前登录用户的真实姓名
 * @returns {string|null} 真实姓名或null
 */
export const getUserRealName = () => {
  return localStorage.getItem('userRealName') || sessionStorage.getItem('userRealName') || null;
};

/**
 * 设置用户真实姓名
 * @param {string} realName - 真实姓名
 * @param {boolean} rememberMe - 是否记住用户（true表示持久化存储）
 */
export const setUserRealName = (realName, rememberMe = false) => {
  if (rememberMe) {
    localStorage.setItem('userRealName', realName);
  } else {
    sessionStorage.setItem('userRealName', realName);
  }
};

/**
 * 清除用户真实姓名
 */
export const removeUserRealName = () => {
  localStorage.removeItem('userRealName');
  sessionStorage.removeItem('userRealName');
};

/**
 * 获取当前登录用户的班级名称
 * @returns {string|null} 班级名称或null
 */
export const getClassName = () => {
  return localStorage.getItem('className') || sessionStorage.getItem('className') || null;
};

/**
 * 设置用户班级名称
 * @param {string} className - 班级名称
 * @param {boolean} rememberMe - 是否记住用户（true表示持久化存储）
 */
export const setClassName = (className, rememberMe = false) => {
  if (rememberMe) {
    localStorage.setItem('className', className);
  } else {
    sessionStorage.setItem('className', className);
  }
};

/**
 * 清除用户班级名称
 */
export const removeClassName = () => {
  localStorage.removeItem('className');
  sessionStorage.removeItem('className');
};

/**
 * 获取当前登录用户的学生ID列表
 * @returns {array|null} 学生ID列表或null
 */
export const getStudentIds = () => {
  const idsStr = localStorage.getItem('studentIds') || sessionStorage.getItem('studentIds') || null;
  return idsStr ? JSON.parse(idsStr) : null;
};

/**
 * 设置学生ID列表
 * @param {array} studentIds - 学生ID列表
 * @param {boolean} rememberMe - 是否记住用户（true表示持久化存储）
 */
export const setStudentIds = (studentIds, rememberMe = false) => {
  const idsStr = JSON.stringify(studentIds);
  if (rememberMe) {
    localStorage.setItem('studentIds', idsStr);
  } else {
    sessionStorage.setItem('studentIds', idsStr);
  }
};

/**
 * 清除学生ID列表
 */
export const removeStudentIds = () => {
  localStorage.removeItem('studentIds');
  sessionStorage.removeItem('studentIds');
};

/**
 * 获取当前登录用户的学生名字列表
 * @returns {array|null} 学生名字列表或null
 */
export const getStudentNames = () => {
  const namesStr = localStorage.getItem('studentNames') || sessionStorage.getItem('studentNames') || null;
  return namesStr ? JSON.parse(namesStr) : null;
};

/**
 * 设置学生名字列表
 * @param {array} studentNames - 学生名字列表
 * @param {boolean} rememberMe - 是否记住用户（true表示持久化存储）
 */
export const setStudentNames = (studentNames, rememberMe = false) => {
  const namesStr = JSON.stringify(studentNames);
  if (rememberMe) {
    localStorage.setItem('studentNames', namesStr);
  } else {
    sessionStorage.setItem('studentNames', namesStr);
  }
};

/**
 * 清除学生名字列表
 */
export const removeStudentNames = () => {
  localStorage.removeItem('studentNames');
  sessionStorage.removeItem('studentNames');
};

/**
 * 清除所有认证信息
 */
export const clearAuthInfo = () => {
  removeToken();
  removeRole();
  removeTeacherId();
  removeUserRealName();
  removeClassName();
  removeStudentIds();
  removeStudentNames();
};

/**
 * 刷新用户认证信息
 * @param {object} authData - 包含token、role、teacher_id、name、real_name、student_ids、student_names的认证数据
 * @param {boolean} rememberMe - 是否记住用户
 * 注意：name字段在响应数据中表示班级名称，real_name字段表示真实姓名
 */
export const refreshAuthInfo = (authData, rememberMe = false) => {
  if (authData.token) {
    setToken(authData.token, rememberMe);
  }
  if (authData.role !== undefined) {
    setRole(authData.role, rememberMe);
  }
  if (authData.teacher_id) {
    setTeacherId(authData.teacher_id.toString(), rememberMe);
  }
  if (authData.name) {
    // name字段在响应数据中表示班级名称
    setClassName(authData.name, rememberMe);
  }
  if (authData.real_name !== undefined) {
    // real_name字段在响应数据中表示真实姓名
    setUserRealName(authData.real_name || '', rememberMe);
  }
  if (authData.student_ids && Array.isArray(authData.student_ids)) {
    setStudentIds(authData.student_ids, rememberMe);
  }
  if (authData.student_names && Array.isArray(authData.student_names)) {
    setStudentNames(authData.student_names, rememberMe);
  }
};

/**
 * 获取认证状态对象
 * @returns {object} 包含认证状态的对象
 */
export const getAuthStatus = () => {
  return {
    isAuthenticated: isAuthenticated(),
    role: getRole(),
    token: getToken(),
    teacherId: getTeacherId(),
    realName: getUserRealName(),
    className: getClassName(),
    studentIds: getStudentIds(),
    studentNames: getStudentNames()
  };
};